<template>

</template>

<script setup>
import * as Cesium from 'cesium';
import TrackGridCell from './Grid2';

let uav2 = null

async function initUav2 (Viewer) {
  uav2 = new TrackGridCell(Viewer, [116.3, 39.9, 50.0])

  const res = await loadGridJson()
  console.log(res[0]);

  Viewer.camera.flyTo({
    destination: Cesium.Cartesian3.fromDegrees(res[0][0][0], res[0][0][1], 50),
    duration: 1
  })


  let i = 0
  setInterval(() => {

    if (i >= res[0].length) {
      i = 0
    }
    const data = res[0][i]
    console.log(data);
    // uav2.drawGridCell(data, 15, 'yellow')

    i++
  }, 1000);
}


async function loadGridJson (params) {
  if (!uav2) {
    console.error('请先初始化 Uav2 实例');
    return;
  }

  try {
    // 获取 json2 目录下的文件列表
    const response = await fetch('/json2/');

    // 如果服务器不支持目录列表，这里需要手动指定文件
    // 可以通过遍历已知的文件范围来加载
    const filePromises = [];

    // 从 dji-uav-0034.json 到 dji-uav-0088.json（根据目录结构可知）
    for (let i = 34; i <= 88; i++) {
      const fileName = `dji-uav-${i.toString().padStart(4, '0')}.json`;
      const filePromise = fetch(`/json2/${fileName}`)
        .then(response => {
          if (!response.ok) {
            throw new Error(`无法加载文件 ${fileName}: ${response.status}`);
          }
          return response.json();
        })
        .then(data => {
          // 处理加载的轨迹数据
          // console.log(`已加载 ${fileName}`);

          // 规范化数据格式为 [经度，纬度，高度]
          const formattedData = formatCoordinateData(data, fileName);

          // 提取坐标点数组，确保返回 [[经度，纬度，高度]，[经度，纬度，高度]....] 格式
          const coordinatePoints = extractCoordinatePoints(formattedData);

          // 返回规范化后的坐标点数组
          return coordinatePoints;
        })
        .catch(error => {
          console.error(`加载 ${fileName} 失败:`, error);
          return null; // 返回 null 以便过滤掉失败的加载
        });

      filePromises.push(filePromise);
    }

    // 等待所有文件加载完成
    const results = await Promise.all(filePromises);

    // 过滤掉加载失败的文件
    const validResults = results.filter(result => result !== null);
    console.log(`成功加载了 ${validResults.length} 个轨迹文件`);

    return validResults;
  } catch (error) {
    console.error('加载网格轨迹文件失败:', error);
    return [];
  }
}

/**
 * 格式化坐标数据，确保为 [经度，纬度，高度] 格式
 * @param {Object|Array} data - 轨迹数据
 * @param {string} fileName - 文件名，用于日志
 * @returns {Object|Array} - 格式化后的数据
 */
function formatCoordinateData (data, fileName) {
  if (!data) return null;

  try {
    // 如果数据是数组形式
    if (Array.isArray(data)) {
      return data.map(item => {
        // 如果是坐标点数组
        if (Array.isArray(item) && item.length >= 2) {
          // 确保是 [经度，纬度，高度] 格式
          const lon = parseFloat(item[0]) || 0;
          const lat = parseFloat(item[1]) || 0;
          const alt = parseFloat(item[2]) || 0;
          return [lon, lat, alt];
        }
        // 如果是对象类型 (可能包含 coordinates 属性)
        else if (item && typeof item === 'object') {
          if (item.coordinates && Array.isArray(item.coordinates)) {
            item.coordinates = formatCoordinateArray(item.coordinates);
          } else if (item.geometry && item.geometry.coordinates) {
            item.geometry.coordinates = formatCoordinateArray(item.geometry.coordinates);
          }
          // 处理可能存在的其他坐标格式
          return item;
        }
        return item;
      });
    }
    // 如果数据是对象形式
    else if (data && typeof data === 'object') {
      // 处理可能存在的坐标数组
      if (data.coordinates && Array.isArray(data.coordinates)) {
        data.coordinates = formatCoordinateArray(data.coordinates);
      }

      // 处理 GeoJSON 格式
      if (data.features && Array.isArray(data.features)) {
        data.features = data.features.map(feature => {
          if (feature.geometry && feature.geometry.coordinates) {
            feature.geometry.coordinates = formatCoordinateArray(feature.geometry.coordinates);
          }
          return feature;
        });
      }

      // 处理轨迹点数组
      if (data.points && Array.isArray(data.points)) {
        data.points = data.points.map(point => {
          if (Array.isArray(point)) {
            return formatCoordinateArray(point);
          }
          return point;
        });
      }
    }

    return data;
  } catch (error) {
    console.error(`格式化文件 ${fileName} 数据时出错:`, error);
    return data; // 出错时返回原始数据
  }
}

/**
 * 格式化坐标数组为 [经度，纬度，高度] 格式
 * @param {Array} coords - 坐标数组
 * @returns {Array} - 格式化后的坐标数组
 */
function formatCoordinateArray (coords) {
  if (!Array.isArray(coords)) return coords;

  // 处理单个坐标点
  if (coords.length >= 2 && !Array.isArray(coords[0])) {
    const lon = parseFloat(coords[0]) || 0;
    const lat = parseFloat(coords[1]) || 0;
    const alt = coords.length >= 3 ? parseFloat(coords[2]) || 0 : 0;
    return [lon, lat, alt];
  }

  // 处理坐标点数组 (如线、多边形等)
  return coords.map(coord => {
    if (Array.isArray(coord)) {
      return formatCoordinateArray(coord);
    }
    return coord;
  });
}

/**
 * 从各种数据结构中提取坐标点数组，统一返回 [[经度，纬度，高度]，[经度，纬度，高度]....] 格式
 * @param {Object|Array} data - 轨迹数据
 * @returns {Array} - 格式化后的坐标点数组
 */
function extractCoordinatePoints (data) {
  const points = [];

  // 如果数据为空，返回空数组
  if (!data) return points;

  try {
    // 处理数组类型数据
    if (Array.isArray(data)) {
      // 如果是坐标点数组的数组，如 [[lon, lat, height], [lon, lat, height], ...]
      if (data.length > 0 && Array.isArray(data[0]) && typeof data[0][0] === 'number') {
        // 确保每个点都是 [经度，纬度，高度] 格式
        return data.map(point => {
          const lon = parseFloat(point[0]) || 0;
          const lat = parseFloat(point[1]) || 0;
          const alt = point.length >= 3 ? parseFloat(point[2]) || 0 : 0;
          return [lon, lat, alt];
        });
      }

      // 如果是对象数组，则递归处理每个对象
      data.forEach(item => {
        if (typeof item === 'object') {
          const extractedPoints = extractCoordinatePoints(item);
          points.push(...extractedPoints);
        }
      });
    }
    // 处理对象类型数据
    else if (typeof data === 'object') {
      // 处理 GeoJSON 类型数据
      if (data.type === 'FeatureCollection' && data.features) {
        data.features.forEach(feature => {
          if (feature.geometry) {
            const geoPoints = extractPointsFromGeometry(feature.geometry);
            points.push(...geoPoints);
          }
        });
      }
      // 处理单个 GeoJSON Feature
      else if (data.type === 'Feature' && data.geometry) {
        const geoPoints = extractPointsFromGeometry(data.geometry);
        points.push(...geoPoints);
      }
      // 处理直接的 GeoJSON Geometry
      else if (data.type && data.coordinates) {
        const geoPoints = extractPointsFromGeometry(data);
        points.push(...geoPoints);
      }
      // 处理可能包含坐标的其他对象
      else {
        // 检查常见的坐标属性
        if (data.coordinates && Array.isArray(data.coordinates)) {
          const coordPoints = extractPointsFromCoordinates(data.coordinates);
          points.push(...coordPoints);
        }
        if (data.points && Array.isArray(data.points)) {
          const pointArray = data.points.map(p => {
            if (Array.isArray(p)) {
              const lon = parseFloat(p[0]) || 0;
              const lat = parseFloat(p[1]) || 0;
              const alt = p.length >= 3 ? parseFloat(p[2]) || 0 : 0;
              return [lon, lat, alt];
            }
            // 如果点是对象格式 {x, y, z} 或 {lon, lat, alt}
            else if (typeof p === 'object') {
              const lon = parseFloat(p.x || p.lon || p.longitude || 0);
              const lat = parseFloat(p.y || p.lat || p.latitude || 0);
              const alt = parseFloat(p.z || p.alt || p.altitude || p.height || 0);
              return [lon, lat, alt];
            }
            return null;
          }).filter(p => p !== null);

          points.push(...pointArray);
        }

        // 递归处理嵌套对象
        for (const key in data) {
          if (typeof data[key] === 'object' && data[key] !== null) {
            const subPoints = extractCoordinatePoints(data[key]);
            points.push(...subPoints);
          }
        }
      }
    }

    return points;
  } catch (error) {
    console.error('提取坐标点数组时出错:', error);
    return points;
  }
}

/**
 * 从 GeoJSON Geometry 中提取坐标点数组
 * @param {Object} geometry - GeoJSON 几何对象
 * @returns {Array} - 提取的坐标点数组
 */
function extractPointsFromGeometry (geometry) {
  if (!geometry || !geometry.type || !geometry.coordinates) {
    return [];
  }

  const points = [];

  switch (geometry.type) {
    case 'Point':
      // Point: [lon, lat, alt]
      points.push(formatCoordinateArray(geometry.coordinates));
      break;
    case 'LineString':
      // LineString: [[lon, lat, alt], [lon, lat, alt], ...]
      geometry.coordinates.forEach(coord => {
        points.push(formatCoordinateArray(coord));
      });
      break;
    case 'Polygon':
      // Polygon: [[[lon, lat, alt], [lon, lat, alt], ...], ...]
      geometry.coordinates.forEach(ring => {
        ring.forEach(coord => {
          points.push(formatCoordinateArray(coord));
        });
      });
      break;
    case 'MultiPoint':
      // MultiPoint: [[lon, lat, alt], [lon, lat, alt], ...]
      geometry.coordinates.forEach(coord => {
        points.push(formatCoordinateArray(coord));
      });
      break;
    case 'MultiLineString':
      // MultiLineString: [[[lon, lat, alt], [lon, lat, alt], ...], ...]
      geometry.coordinates.forEach(line => {
        line.forEach(coord => {
          points.push(formatCoordinateArray(coord));
        });
      });
      break;
    case 'MultiPolygon':
      // MultiPolygon: [[[[lon, lat, alt], [lon, lat, alt], ...], ...], ...]
      geometry.coordinates.forEach(polygon => {
        polygon.forEach(ring => {
          ring.forEach(coord => {
            points.push(formatCoordinateArray(coord));
          });
        });
      });
      break;
  }

  return points;
}

/**
 * 从坐标数组中提取坐标点
 * @param {Array} coordinates - 坐标数组
 * @returns {Array} - 提取的坐标点数组
 */
function extractPointsFromCoordinates (coordinates) {
  const points = [];

  // 如果是单个坐标点
  if (coordinates.length >= 2 && typeof coordinates[0] === 'number') {
    points.push(formatCoordinateArray(coordinates));
    return points;
  }

  // 如果是坐标数组
  function traverse (coords) {
    if (Array.isArray(coords)) {
      if (coords.length >= 2 && typeof coords[0] === 'number') {
        points.push(formatCoordinateArray(coords));
      } else {
        coords.forEach(c => traverse(c));
      }
    }
  }

  traverse(coordinates);
  return points;
}

defineExpose({
  initUav2
})
</script>

<style scoped lang="scss"></style>